src/Modules/SearchProviders/Tests/Unit/Domain/Models/SearchResultTests.cs (1)

188-197: Prefira SlugHelper.Generate no teste para evitar divergência de regra.

Hoje o teste duplica a lógica de slug manualmente; isso pode mascarar regressões quando a regra oficial mudar.

Refactor sugerido

+using MeAjudaAi.Shared.Utilities;
...
 var providerName = _faker.Company.CompanyName();
 var provider = SearchableProvider.Create(
     providerId: providerId,
     name: providerName,
-    slug: providerName.ToLower().Replace(" ", "-"),
+    slug: SlugHelper.Generate(providerName),
     location: location,
     subscriptionTier: _faker.Random.Enum<ESubscriptionTier>(),

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/SearchProviders/Tests/Unit/Domain/Models/SearchResultTests.cs`
around lines 188 - 197, O teste está replicando a lógica de geração de slug
manualmente; em vez de usar providerName.ToLower().Replace(" ", "-") passe o
slug gerado por SlugHelper.Generate(providerName) ao criar o objeto via
SearchableProvider.Create (referenciar providerName e o parâmetro slug) para
garantir que o teste acompanhe a regra oficial de geração de slugs.

prompts/design-react-project.md (1)

138-152: Adicione especificador de linguagem ao bloco de código.

O bloco de código para variáveis CSS não possui especificador de linguagem, o que dispara um aviso do markdownlint. Adicione css ou text para melhorar a formatação e silenciar o warning.

📝 Sugestão de correção

-```
+```css
 bg-surface, bg-surface-raised       → fundos

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@prompts/design-react-project.md` around lines 138 - 152, The code block
containing the CSS variable mappings (lines with identifiers like bg-surface,
bg-primary, bg-destructive, text-foreground, border-border, ring-ring, etc.)
lacks a language specifier; update the fenced code block start to include a
language (e.g., ```css or ```text) so markdownlint warning is silenced and
formatting is improved—locate the block showing the mappings and change the
opening fence to ```css.

tests/MeAjudaAi.Shared.Tests/Unit/Utilities/SlugHelperTests.cs (1)

6-7: Considere adicionar o atributo de categoria para consistência.

Os outros arquivos de teste no projeto utilizam [Trait("Category", "Unit")] para categorização. Adicionar este atributo manteria a consistência e facilitaria a filtragem de testes por categoria.

♻️ Sugestão de refatoração

+[Trait("Category", "Unit")]
 public class SlugHelperTests

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/MeAjudaAi.Shared.Tests/Unit/Utilities/SlugHelperTests.cs` around lines
6 - 7, A classe de teste SlugHelperTests está faltando a categorização
consistente usada no projeto; adicione o atributo [Trait("Category", "Unit")]
acima da declaração da classe SlugHelperTests (ou em cada método de teste se
preferir granularidade) para alinhar com os outros testes; verifique que o
namespace/xUnit esteja disponível (usando Xunit) e mantenha o mesmo padrão de
categoria usado pelo restante do repositório.

src/Modules/SearchProviders/Infrastructure/Persistence/Configurations/SearchableProviderConfiguration.cs (1)

44-47: Padronize o limite de tamanho do Slug entre Providers e SearchProviders.

Aqui está 200, mas no módulo Providers está 120. Vale alinhar (ou extrair constante compartilhada) para evitar drift de schema/regra de domínio.

Based on learnings: prioritize reuse of Shared.Contracts for enums/constants to keep Web aligned with backend/shared code.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Infrastructure/Persistence/Configurations/SearchableProviderConfiguration.cs`
around lines 44 - 47, In SearchableProviderConfiguration (builder.Property(p =>
p.Slug)) the Slug max length is set to 200 but Providers uses 120; change
HasMaxLength(200) to the shared canonical value (preferably use the constant
from Shared.Contracts, e.g. import and reference the Slug length constant) or
set it to 120 to match Providers, and update any related EF migration/schema to
keep database and domain rules aligned.

src/Modules/Providers/Tests/Unit/Infrastructure/Events/Handlers/ProviderRegisteredDomainEventHandlerTests.cs (1)

70-71: Boa atualização dos testes para o novo construtor, mas falta validar o payload do Slug.

Como este PR introduz Slug no evento de domínio, vale reforçar o Verify para checar o conteúdo publicado (não só o tipo), assim que o contrato de integração expuser esse campo.

Also applies to: 96-97, 123-124

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Infrastructure/Events/Handlers/ProviderRegisteredDomainEventHandlerTests.cs`
around lines 70 - 71, Atualize os asserts/verificações nos testes em
ProviderRegisteredDomainEventHandlerTests para não só checar o tipo do evento
publicado, mas também validar o payload.Slug; especificamente, ao verificar a
chamada de Publish/Send (o Verify usando o mock do bus ou publisher), confirme
que o evento publicado (ProviderRegisteredDomainEvent) tem a propriedade Slug
igual a "provider-test". Aplique a mesma verificação nas outras ocorrências
apontadas (asserções nas seções correspondentes às linhas 96-97 e 123-124) para
garantir que todos os testes validem o conteúdo do Slug além do tipo do evento.

src/Modules/Providers/Application/Mappers/ProviderMapper.cs (1)

17-36: Mistura inconsistente de parâmetros nomeados e posicionais.

O método começa com parâmetros nomeados (linhas 18-22: Id, UserId, Name, Slug, Type) mas depois muda para parâmetros posicionais (linhas 23-35). Isso reduz a legibilidade e aumenta o risco de erros se a ordem dos parâmetros do construtor mudar.

♻️ Usar parâmetros nomeados consistentemente

     public static ProviderDto ToDto(this Provider provider)
     {
         return new ProviderDto(
             Id: provider.Id.Value,
             UserId: provider.UserId,
             Name: provider.Name,
             Slug: provider.Slug,
             Type: provider.Type,
-            provider.BusinessProfile.ToDto(),
-            provider.Status,
-            provider.VerificationStatus,
-            provider.Tier,
-            provider.Documents.Select(d => d.ToDto()).ToList(),
-            provider.Qualifications.Select(q => q.ToDto()).ToList(),
-            provider.Services.Select(s => s.ToDto()).ToList(),
-            provider.CreatedAt,
-            provider.UpdatedAt,
-            provider.IsDeleted,
-            provider.DeletedAt,
-            provider.SuspensionReason,
-            provider.RejectionReason
+            BusinessProfile: provider.BusinessProfile.ToDto(),
+            Status: provider.Status,
+            VerificationStatus: provider.VerificationStatus,
+            Tier: provider.Tier,
+            Documents: provider.Documents.Select(d => d.ToDto()).ToList(),
+            Qualifications: provider.Qualifications.Select(q => q.ToDto()).ToList(),
+            Services: provider.Services.Select(s => s.ToDto()).ToList(),
+            CreatedAt: provider.CreatedAt,
+            UpdatedAt: provider.UpdatedAt,
+            IsDeleted: provider.IsDeleted,
+            DeletedAt: provider.DeletedAt,
+            SuspensionReason: provider.SuspensionReason,
+            RejectionReason: provider.RejectionReason
         );
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Providers/Application/Mappers/ProviderMapper.cs` around lines 17
- 36, O trecho que instancia ProviderDto mistura argumentos nomeados e
posicionais; abraçar consistência e segurança: atualize a chamada em
ProviderMapper para usar apenas parâmetros nomeados (por exemplo Id:, UserId:,
Name:, Slug:, Type:, BusinessProfile:, Status:, VerificationStatus:, Tier:,
Documents:, Qualifications:, Services:, CreatedAt:, UpdatedAt:, IsDeleted:,
DeletedAt:, SuspensionReason:, RejectionReason:) referenciando as propriedades
atuais (p.ex. provider.BusinessProfile.ToDto(),
provider.Documents.Select(...).ToList(), etc.), garantindo que cada valor
corresponda explicitamente ao parâmetro do construtor ProviderDto.

src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs (2)

164-172: Derivação de slug inconsistente com a produção.

Assim como no arquivo de testes unitários do repositório, a geração de slug aqui usa name.ToLower().Replace(" ", "-") (linha 167), que não corresponde ao comportamento de SlugHelper.Generate(). Em testes de integração isso é ainda mais crítico, pois os dados persistidos no banco podem ter slugs que nunca seriam gerados em produção.

♻️ Usar SlugHelper.Generate para consistência

         var provider = SearchableProvider.Create(
             providerId: providerId,
             name: name,
-            slug: name.ToLower().Replace(" ", "-"),
+            slug: SlugHelper.Generate(name),
             location: location,
             subscriptionTier: tier,
             description: description,
             city: city,
             state: state);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
around lines 164 - 172, A geração de slug em SearchableProvider.Create está
usando name.ToLower().Replace(" ", "-"), o que difere do comportamento de
produção; substitua essa expressão pelo uso de SlugHelper.Generate(name) ao
construir o argumento slug (na chamada de SearchableProvider.Create) e
importe/ajuste o namespace se necessário para garantir que os slugs em testes de
integração sejam gerados exatamente como em produção.

---

192-200: Mesma inconsistência de slug no segundo helper.

O método CreateTestSearchableProviderWithProviderId também usa a derivação naive de slug na linha 195.

♻️ Usar SlugHelper.Generate para consistência

         var provider = SearchableProvider.Create(
             providerId: providerId,
             name: name,
-            slug: name.ToLower().Replace(" ", "-"),
+            slug: SlugHelper.Generate(name),
             location: location,
             subscriptionTier: tier,
             description: description,
             city: city,
             state: state);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
around lines 192 - 200, The CreateTestSearchableProviderWithProviderId helper
currently derives the slug naively using name.ToLower().Replace(" ", "-");
update this to use the centralized SlugHelper.Generate method for consistency —
modify the provider creation in CreateTestSearchableProviderWithProviderId (the
SearchableProvider.Create(...) call that sets slug) to call
SlugHelper.Generate(name) instead of the manual replace so slugs match other
helpers.

src/Modules/SearchProviders/Tests/Unit/Infrastructure/Repositories/SearchableProviderRepositoryTests.cs (1)

53-67: Derivação de slug inconsistente com a produção.

A geração de slug na linha 55 usa actualName.ToLower().Replace(" ", "-"), que difere significativamente do SlugHelper.Generate() usado em produção. O helper de produção também:

1. Remove diacríticos (ex: "café" → "cafe")
2. Remove caracteres não-alfanuméricos (ex: "&" é removido)
3. Colapsa hífens duplicados
4. Faz trim de hífens nas extremidades

Isso pode criar dados de teste que nunca existiriam em produção, potencialmente mascarando bugs ou causando falsos positivos.

♻️ Usar SlugHelper.Generate para consistência

-        var actualSlug = actualName.ToLower().Replace(" ", "-");
+        var actualSlug = SlugHelper.Generate(actualName);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Infrastructure/Repositories/SearchableProviderRepositoryTests.cs`
around lines 53 - 67, The test builds a slug with actualName.ToLower().Replace("
", "-") which diverges from production slug behavior; update the test to
generate slugs using the same production helper (call
SlugHelper.Generate(actualName) when constructing the SearchableProvider in
SearchableProvider.Create) so diacritics, non-alphanumerics, duplicate hyphens
and edge hyphens are handled consistently with production (ensure any required
using/import for SlugHelper is added).

src/Modules/Providers/Tests/Unit/Infrastructure/Events/Handlers/ProviderProfileUpdatedDomainEventHandlerTests.cs (1)

43-46: Documentação XML deve estar em Português.

As tags <summary> estão em inglês, mas de acordo com a política de linguagem do projeto, comentários e documentação XML devem estar em Português.

📝 Traduzir documentação XML para Português

-    /// <summary>
-    /// Verifies that HandleAsync publishes a ProviderProfileUpdatedIntegrationEvent with correct provider details
-    /// when processing a valid profile update domain event.
-    /// </summary>
+    /// <summary>
+    /// Verifica que HandleAsync publica um ProviderProfileUpdatedIntegrationEvent com os detalhes corretos do provedor
+    /// ao processar um evento de domínio de atualização de perfil válido.
+    /// </summary>

-    /// <summary>
-    /// Verifies that when message bus publishing fails, the handler logs an error containing
-    /// "Error handling ProviderProfileUpdatedDomainEvent" and re-throws the exception.
-    /// </summary>
+    /// <summary>
+    /// Verifica que quando a publicação no message bus falha, o handler registra um erro contendo
+    /// "Error handling ProviderProfileUpdatedDomainEvent" e relança a exceção.
+    /// </summary>

Baseado em learnings: "Comments and XML documentation can remain in Portuguese, logs should be in English".

Also applies to: 82-85

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Infrastructure/Events/Handlers/ProviderProfileUpdatedDomainEventHandlerTests.cs`
around lines 43 - 46, A documentação XML nas tags <summary> para o teste que
descreve a verificação de HandleAsync deve ser traduzida para Português;
localize no arquivo ProviderProfileUpdatedDomainEventHandlerTests (as
ocorrências atuais nas linhas próximas aos trechos que descrevem "Verifies that
HandleAsync publishes a ProviderProfileUpdatedIntegrationEvent..." e a segunda
ocorrência perto das linhas 82-85) e substitua o texto em inglês por um resumo
em Português mantendo as mesmas tags XML /// <summary> ... </summary>, por
exemplo descrevendo que o teste verifica se HandleAsync publica um
ProviderProfileUpdatedIntegrationEvent com os detalhes corretos do provider;
preserve a formatação XML e outros comentários adjacentes.

src/Shared/Utilities/SlugHelper.cs (1)

26-48: Implementação sólida com uma consideração de edge case.

A implementação está bem estruturada usando GeneratedRegex para performance. Um edge case a considerar: se o texto de entrada contiver apenas caracteres especiais (ex: "!@#$%"), o método retornará uma string vazia, o que causará ArgumentException em SearchableProvider.Create() e UpdateBasicInfo().

Isso é comportamento defensivo adequado, mas pode ser útil documentar ou validar isso no ponto de entrada (ex: validação de nome do provider antes de gerar o slug).

📝 Sugestão: Adicionar documentação sobre o edge case

     /// <summary>
     /// Gera um slug a partir de um texto
     /// </summary>
     /// <param name="text">Texto original</param>
-    /// <returns>Slug formatado</returns>
+    /// <returns>Slug formatado ou string vazia se o texto não contiver caracteres alfanuméricos válidos</returns>
+    /// <remarks>
+    /// Se o texto contiver apenas caracteres especiais, o método retornará string vazia.
+    /// Chamadores devem validar o resultado antes de usar em contextos que requerem slug não-vazio.
+    /// </remarks>
     public static string Generate(string text)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Shared/Utilities/SlugHelper.cs` around lines 26 - 48, The Generate method
can return an empty string for inputs with only non-alphanumeric chars (e.g.
"!@#$%"), which later causes an ArgumentException in SearchableProvider.Create
and UpdateBasicInfo; add defensive validation at the call sites: in
SearchableProvider.Create and UpdateBasicInfo, validate the provider name (not
null/whitespace) before calling SlugHelper.Generate, then call Generate and if
it returns null/empty throw a clear ArgumentException (or return a meaningful
default/validation error) that explains the name produced no valid slug;
alternatively, if you prefer centralizing the check, modify SlugHelper.Generate
to detect the empty-result case and either throw a descriptive ArgumentException
or return a documented fallback value, and update callers to handle that
behavior accordingly.

src/Modules/SearchProviders/Tests/Unit/Application/Handlers/SearchProvidersQueryHandlerTests.cs (1)

357-362: Prefira gerar o Slug com a mesma utility da produção.

Os fixtures aqui misturam slug hardcoded e ToLower().Replace(" ", "-"), o que pode divergir do SlugHelper em casos de acento, pontuação ou múltiplos espaços. Vale centralizar isso para os testes continuarem refletindo a regra real.

♻️ Exemplo

+using MeAjudaAi.Shared.Utilities;
...
             var name = $"Provider {i + 1}";
+            var slug = SlugHelper.Generate(name);
             providers.Add(SearchableProvider.Create(
                 providerId: Guid.NewGuid(),
                 name: name,
-                slug: name.ToLower().Replace(" ", "-"),
+                slug: slug,
                 location: new GeoPoint(-23.5505 + i * 0.01, -46.6333 + i * 0.01),

Also applies to: 396-405

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Application/Handlers/SearchProvidersQueryHandlerTests.cs`
around lines 357 - 362, Os fixtures criam slugs manualmente, o que pode divergir
da lógica de produção; update os testes para gerar o slug usando a mesma utility
que a aplicação usa (ex.: SlugHelper or whatever slug generator is used) ao
construir o SearchableProvider via SearchableProvider.Create so that
providerId/name/slug use the canonical slugging logic; apply the same change to
the other fixture block referenced (around the 396-405 area) so tests mirror
production behavior for accents, punctuation and multiple spaces.

src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs (1)

26-34: Faltam cenários para a nova invariável de Slug.

A suíte foi adaptada para passar slug, mas ainda não cobre os novos guards de Create/UpdateBasicInfo nem a normalização para lowercase. Um teste com slug vazio/branco e outro verificando o valor normalizado protegeriam melhor a mudança.

Also applies to: 58-63, 73-77, 90-111

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs`
around lines 26 - 34, Os testes faltam cenários cobrindo a nova invariável slug:
adicione casos unitários em SearchableProviderTests que verifiquem (1) que
Create(...) e UpdateBasicInfo(...) falham (lançam/retornam erro de validação)
quando slug é null/empty/whitespace e (2) que quando um slug válido com letras
maiúsculas é passado, o valor armazenado em SearchableProvider.Slug é
normalizado para lowercase; foque nas chamadas SearchableProvider.Create(...) e
no método UpdateBasicInfo(...) para inserir asserts que confirmem as guards e a
normalização.

src/Modules/SearchProviders/Tests/Unit/Application/ModuleApi/SearchProvidersModuleApiTests.cs (1)

158-222: Os testes ainda não validam a propagação do Slug.

Os fixtures agora populam Slug, mas as asserções só conferem contagem/chamada ao repositório. Se o mapping da API devolver ou persistir o slug errado, esses cenários continuam verdes. Vale validar o Slug no resultado de busca e nas entidades enviadas para AddAsync/UpdateAsync.

♻️ Exemplo

         provider.ProviderId.Should().Be(providerId);
         provider.Name.Should().Be("Provider 1");
+        provider.Slug.Should().Be("provider-1");
...
-        _repositoryMock.Verify(x => x.AddAsync(It.IsAny<SearchableProvider>(), It.IsAny<CancellationToken>()), Times.Once);
+        _repositoryMock.Verify(x => x.AddAsync(
+            It.Is<SearchableProvider>(p => p.Slug == "test-provider"),
+            It.IsAny<CancellationToken>()), Times.Once);
...
-        _repositoryMock.Verify(x => x.UpdateAsync(existingProvider, It.IsAny<CancellationToken>()), Times.Once);
+        _repositoryMock.Verify(x => x.UpdateAsync(
+            It.Is<SearchableProvider>(p => p.Slug == "updated-provider"),
+            It.IsAny<CancellationToken>()), Times.Once);

Also applies to: 327-357, 375-405, 468-509

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Application/ModuleApi/SearchProvidersModuleApiTests.cs`
around lines 158 - 222, The tests currently don't assert that the provider Slug
is propagated; update the unit tests that exercise SearchProvidersAsync (and the
other search/add/update tests mentioned) to assert provider.Slug equals the
expected "provider-1" in the returned ModuleSearchableProviderDto (from
PagedResult<SearchableProviderDto>) and add mock verifications that repository
methods (e.g., AddAsync/UpdateAsync) are called with entities whose Slug
property equals the expected slug; locate assertions around
result.Value.Items[0] (variable provider) and the mock setups on
_queryDispatcherMock and repository mocks to add these Slug checks so mapping
and persistence of Slug are validated.

src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs (1)

165-173: Alinhe o fixture com a estratégia real de slug do Provider.

Aqui o teste monta SearchableProvider.Slug com SlugHelper.Generate(name), mas o fluxo real usa SlugHelper.GenerateWithSuffix(Name, Id.Value.ToString("N")[..8]) em src/Modules/Providers/Domain/Entities/Provider.cs. Isso faz a suíte exercitar um formato que não existe em produção e pode esconder bugs de rota/colisão ligados ao sufixo.

♻️ Ajuste sugerido

-            slug: SlugHelper.Generate(name),
+            slug: SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]),

Also applies to: 193-201

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
around lines 165 - 173, O fixture está gerando o slug com
SlugHelper.Generate(name) enquanto o domínio real usa
SlugHelper.GenerateWithSuffix(Name, Id.Value.ToString("N")[..8]) em Provider.cs;
atualize a chamada ao criar o fixture (SearchableProvider.Create) para gerar o
slug com SlugHelper.GenerateWithSuffix passando o nome e o sufixo extraído do
providerId (ou do Id em formato "N" e tomando os 8 primeiros caracteres) para
espelhar a estratégia de produção e evitar discrepâncias de rota/colisão.

src/Shared/Utilities/SlugHelper.cs (1)

56-60: ⚠️ Potential issue | 🟡 Minor

Sanitize o suffix para evitar slug malformado (base- ou caracteres inválidos).

Hoje o sufixo é anexado sem normalização/validação. Se vier vazio ou com caracteres não amigáveis para URL, o resultado pode ficar inconsistente.

🔧 Ajuste sugerido

 public static string GenerateWithSuffix(string text, string suffix)
 {
     var baseSlug = Generate(text);
-    return string.IsNullOrEmpty(baseSlug) ? suffix : $"{baseSlug}-{suffix}";
+    var normalizedSuffix = Generate(suffix);
+
+    if (string.IsNullOrWhiteSpace(baseSlug))
+        return normalizedSuffix;
+
+    if (string.IsNullOrWhiteSpace(normalizedSuffix))
+        return baseSlug;
+
+    return $"{baseSlug}-{normalizedSuffix}";
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Shared/Utilities/SlugHelper.cs` around lines 56 - 60, A função
GenerateWithSuffix está anexando o suffix sem normalização, permitindo
resultados como "base-" ou caracteres inválidos; para corrigir, normalize e
sanitize o suffix antes de concatenar (por exemplo reaproveitando a lógica de
limpeza já existente em Generate: calcular suffixSlug = Generate(suffix.Trim())
), então aplicar estas regras em GenerateWithSuffix: se suffixSlug for vazio
retorne apenas baseSlug; se baseSlug for vazio retorne suffixSlug; caso ambos
existam retorne $"{baseSlug}-{suffixSlug}". Atualize GenerateWithSuffix para
usar Generate para validar/normalizar o suffix e evitar traços finais ou
caracteres inválidos.

src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs (1)

193-201: Padronize o segundo helper para também usar GenerateWithSuffix.

Usar só Generate(name) aqui pode gerar colisões em cenários de teste com nomes repetidos.

🔧 Ajuste sugerido

-            slug: SlugHelper.Generate(name),
+            slug: SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]),

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
around lines 193 - 201, Alterar o helper usado ao criar o provider para evitar
colisões em testes: na chamada SearchableProvider.Create substitua
SlugHelper.Generate(name) por SlugHelper.GenerateWithSuffix(name) (ou
equivalente overload) para que o slug inclua um sufixo único; atualize qualquer
import/uso relacionado se necessário para compilar e mantenha o restante dos
parâmetros (providerId, name, location, etc.) inalterados.

src/Modules/SearchProviders/Domain/Entities/SearchableProvider.cs (1)

129-130: Centralize a normalização de slug no SlugHelper para manter consistência entre módulos.

NormalizeSlug atual só faz trim + lowercase. Isso diverge da regra canônica usada em Provider e pode persistir slug não padronizado.

♻️ Refactor sugerido

+using MeAjudaAi.Shared.Utilities;
@@
     private static string NormalizeSlug(string slug)
     {
-        var normalized = slug.Trim().ToLowerInvariant();
+        var normalized = SlugHelper.Generate(slug);
         if (string.IsNullOrEmpty(normalized))
             throw new ArgumentException("Provider slug cannot be empty.", nameof(slug));
         return normalized;
     }

Also applies to: 138-144, 177-177, 206-206

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/SearchProviders/Domain/Entities/SearchableProvider.cs` around
lines 129 - 130, Replace local NormalizeSlug usage in SearchableProvider with
the canonical slug normalizer from SlugHelper to ensure consistent rules with
Provider; specifically, update assignments and any calls in the
SearchableProvider class (e.g., the Slug property initializer and the other
occurrences noted) to call SlugHelper.NormalizeSlug (the same method used by
Provider) instead of the local NormalizeSlug implementation, remove duplicate
trim/lowercase logic from SearchableProvider, and ensure the class imports/uses
SlugHelper so all slug generation follows the centralized canonical
implementation.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs (1)

48-48: Falta um teste cobrindo o fluxo novo por slug.

Todos os cenários continuam enviando GUID em formato string e mockando apenas GetByIdAsync, então o branch GetBySlugAsync pode quebrar sem falhar nesta suíte. Vale adicionar pelo menos um caso com provider.Slug.

Also applies to: 73-73, 93-93, 128-128

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs`
at line 48, Add a test case that exercises the "by slug" path: instantiate
GetPublicProviderByIdOrSlugQuery with provider.Slug (not provider.Id) and update
the repository mock to setup/verify GetBySlugAsync is called and returns the
provider, not only GetByIdAsync; ensure the handler under test
(GetPublicProviderByIdQueryHandler or the test methods at lines around
48/73/93/128) asserts the same expected result as the existing ID-based tests so
the GetBySlugAsync branch is covered.

src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs (1)

168-168: Extraia a geração de slug de teste para um helper local.

A expressão SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]) está duplicada; centralizar evita drift se a regra de montagem mudar.

♻️ Refactor opcional

+    private static string BuildTestSlug(string name, Guid providerId) =>
+        SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]);

...
-            slug: SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]),
+            slug: BuildTestSlug(name, providerId),
...
-            slug: SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]),
+            slug: BuildTestSlug(name, providerId),

Also applies to: 196-196

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
at line 168, Extrair a lógica duplicada de criação de slug em
SearchProvidersIntegrationTestBase para um helper local: criar um método privado
(por exemplo GetTestSlug or BuildTestSlug) que recebe name e providerId e
retorna SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]), e
substituir ambas as ocorrências atuais que chamam
SlugHelper.GenerateWithSuffix(...) pelo novo método; referencie o nome da classe
SearchProvidersIntegrationTestBase e a chamada SlugHelper.GenerateWithSuffix
para localizar os pontos a alterar.

src/Shared/Utilities/Constants/ApiEndpoints.cs (1)

52-52: Boa correção da rota; só alinhe o comentário inline.

/public/{idOrSlug} elimina a sobreposição com /{id:guid}, mas o comentário ainda aponta para GetPublicProviderByIdEndpoint. Vale atualizar para o nome atual para não confundir manutenção e buscas no código.

✏️ Ajuste sugerido

-        public const string GetPublicByIdOrSlug = "/public/{idOrSlug}";  // GET GetPublicProviderByIdEndpoint
+        public const string GetPublicByIdOrSlug = "/public/{idOrSlug}";  // GET GetPublicProviderByIdOrSlugEndpoint

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Shared/Utilities/Constants/ApiEndpoints.cs` at line 52, Atualize o
comentário inline que segue a constante GetPublicByIdOrSlug para referir o nome
atual do endpoint (substituir a referência obsoleta
GetPublicProviderByIdEndpoint por o nome real usado no código hoje, por exemplo
GetPublicByIdOrSlugEndpoint ou o identificador atual do handler), mantendo o
formato de comentário existente para evitar confusão em buscas e manutenção;
localize a constante GetPublicByIdOrSlug e altere apenas o texto do comentário
anotado após ela.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs (1)

61-87: Cubra a propagação do slug no DTO neste teste.

Este caso novo valida o lookup por slug, mas ainda passaria se a busca funcionasse e o mapeamento de Slug no PublicProviderDto quebrasse. Como o slug é parte central deste PR, vale travar essa garantia aqui também.

✅ Ajuste sugerido

         // Assert
         result.IsSuccess.Should().BeTrue();
         result.Value.Should().NotBeNull();
         result.Value!.Id.Should().Be(provider.Id);
+        result.Value.Slug.Should().Be(provider.Slug);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs`
around lines 61 - 87, Atualize o teste
HandleAsync_WhenProviderQueriedBySlug_ShouldReturnDto para também verificar que
o slug do DTO é propagado: após chamar _handler.HandleAsync(query, ...), assert
que result.Value (o PublicProviderDto retornado) não é nulo e que
result.Value.Slug é igual a provider.Slug; isso garante que o mapping para
PublicProviderDto inclui o campo Slug (verifique o fluxo envolvendo
GetPublicProviderByIdOrSlugQuery,
_providerRepositoryMock.Setup(...GetBySlugAsync...), e a construção do Provider
via ProviderBuilder).

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs (1)

21-27: Alinhe o nome da suíte com o comportamento ByIdOrSlug.

A suíte ainda se chama GetPublicProviderByIdQueryHandlerTests, mas agora valida GetPublicProviderByIdOrSlugQueryHandler. Renomear classe/arquivo melhora rastreabilidade e manutenção.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs`
around lines 21 - 27, Renomeie a suíte de testes e referências para refletir o
comportamento "ByIdOrSlug": altere a classe de
GetPublicProviderByIdQueryHandlerTests para
GetPublicProviderByIdOrSlugQueryHandlerTests, atualize o nome do ficheiro
correspondente e verifique o construtor e quaisquer referências internas (por
exemplo, o campo _handler já instancia GetPublicProviderByIdOrSlugQueryHandler)
para usar o novo nome da classe; ajuste também quaisquer atributos de test
runner ou namespaces que referenciem o antigo nome.

src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs (1)

166-173: ⚠️ Potential issue | 🔴 Critical

BuildTestSlug está ausente e quebra a compilação do projeto.

As chamadas BuildTestSlug(name, providerId) não resolvem para nenhum método na classe, resultando em CS0103 (linhas reportadas no pipeline). Esse é um bloqueador de merge.

🔧 Correção sugerida

@@
     protected SearchableProvider CreateTestSearchableProviderWithProviderId(
         Guid providerId,
         string name,
         double latitude,
@@
         return provider;
     }
+
+    /// <summary>
+    /// Gera slug determinístico para cenários de teste.
+    /// </summary>
+    private static string BuildTestSlug(string name, Guid providerId)
+    {
+        return SlugHelper.GenerateWithSuffix(name, providerId.ToString("N"));
+    }
 
     /// <summary>
     /// Persiste um SearchableProvider no banco de dados
     /// </summary>

Also applies to: 194-201

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
around lines 166 - 173, The code calls BuildTestSlug(name, providerId) but the
method is missing, causing CS0103; add a private static (or appropriate
visibility) helper method named BuildTestSlug in the
SearchProvidersIntegrationTestBase class that returns a string slug (e.g.,
normalize/slugify the name and include providerId or concatenate them) and use
it for the existing calls at the provider creation sites referenced (the calls
around providerId/name at lines shown and the duplicate calls around the other
block). Ensure the method signature matches the usage (BuildTestSlug(string
name, Guid providerId) or the actual providerId type) and handles null/empty
name safely.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs (2)

61-88: Adicione o cenário de slug não encontrado.

O caminho novo por slug só está coberto no happy path. Se GetBySlugAsync retornar null, uma regressão nesse branch passa sem proteção de teste.

💡 Exemplo de cenário adicional

[Fact]
public async Task HandleAsync_WhenProviderSlugNotFound_ShouldReturnNotFound()
{
    // Arrange
    const string slug = "provider-inexistente";

    _providerRepositoryMock
        .Setup(x => x.GetBySlugAsync(slug, It.IsAny<CancellationToken>()))
        .ReturnsAsync((Provider?)null);

    var query = new GetPublicProviderByIdOrSlugQuery(slug);

    // Act
    var result = await _handler.HandleAsync(query, CancellationToken.None);

    // Assert
    result.IsSuccess.Should().BeFalse();
    result.Error.StatusCode.Should().Be(404);
}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs`
around lines 61 - 88, Add a unit test for the "slug not found" branch: mock
_providerRepositoryMock.Setup(x => x.GetBySlugAsync(slug,
It.IsAny<CancellationToken>())).ReturnsAsync((Provider?)null), create a
GetPublicProviderByIdOrSlugQuery with that slug, call
_handler.HandleAsync(query, CancellationToken.None) and assert the result
indicates failure (IsSuccess false) and that the error StatusCode is 404; this
covers the branch where GetBySlugAsync returns null and prevents regressions in
HandleAsync.

---

70-70: Mantenha comentários inline em português.

Os cabeçalhos AAA podem continuar em inglês, mas este comentário novo foge da convenção do repositório.

💬 Ajuste sugerido

-        // Bypass domain transitions to set Active status directly for test
+        // Ignora as transições de domínio para definir o status Active diretamente no teste

Based on learnings: In all C# files, keep logging messages in English, but ensure comments and XML documentation (///

, /// , etc.) are written in Portuguese across the codebase; in unit test code, keep AAA headers in tests (Arrange, Act, Assert) in English and do not translate them.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdQueryHandlerTests.cs`
at line 70, Summary: Comentário inline em inglês quebra a convenção do
repositório; substitua por português mantendo cabeçalhos AAA em inglês. Atualize
o comentário "// Bypass domain transitions to set Active status directly for
test" no arquivo de teste GetPublicProviderByIdQueryHandlerTests.cs para uma
versão em português (por exemplo: "// Contornar transições de domínio para
definir o status Active diretamente no teste"), garantindo que os cabeçalhos
Arrange/Act/Assert dentro do mesmo teste permaneçam em inglês.

src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs (1)

282-282: Evite número mágico ao truncar o Guid no sufixo.

Na Line 282, [..8] pode virar constante nomeada para facilitar manutenção futura.

💡 Refactor opcional

+    private const int TestSlugSuffixLength = 8;
+
     private static string BuildTestSlug(string name, Guid providerId)
     {
-        return SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]);
+        return SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..TestSlugSuffixLength]);
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Integration/SearchProvidersIntegrationTestBase.cs`
at line 282, Extrair o literal de truncamento do GUID usado em
SlugHelper.GenerateWithSuffix para uma constante nomeada (por exemplo const int
GuidSuffixLength = 8) e usar essa constante ao invés de usar o slice literal
providerId.ToString("N")[..8]; atualize a chamada para usar
providerId.ToString("N").Substring(0, GuidSuffixLength) ou o equivalente de
slicing com a constante para tornar o propósito claro e facilitar manutenção;
referência: SlugHelper.GenerateWithSuffix e providerId.ToString("N")[..8].

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (2)

70-72: Asserção de null ausente para consistência.

A verificação statusProp.Should().NotBeNull() está presente nos outros testes (linhas 41 e 146), mas foi omitida aqui antes de usar statusProp!.SetValue. Para manter consistência e clareza, considere adicionar a asserção.

♻️ Sugestão de correção

         // Bypass domain transitions to set Active status directly for test
         var statusProp = typeof(Provider).GetProperty(nameof(Provider.Status));
+        statusProp.Should().NotBeNull("Provider.Status property must exist");
         statusProp!.SetValue(provider, EProviderStatus.Active);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 70 - 72, Add a null assertion before using the reflected Status
property: verify statusProp is not null with statusProp.Should().NotBeNull() (as
done in the other tests) immediately after obtaining it from
typeof(Provider).GetProperty(nameof(Provider.Status)) and before calling
statusProp!.SetValue(provider, EProviderStatus.Active); this ensures consistency
and avoids relying on the null-forgiving operator without an assertion.

---

61-88: Considere adicionar testes para casos de borda.

O teste de busca por slug está correto, mas baseado na lógica do handler (que usa Guid.TryParse para rotear entre ID e slug), há casos de borda importantes não cobertos:

1. Slug que poderia ser um GUID válido: Se um slug fosse acidentalmente um GUID válido, seria roteado para GetByIdAsync em vez de GetBySlugAsync.

2. Sensibilidade a maiúsculas/minúsculas: O GetBySlugAsync faz comparação exata (p.Slug == slug), mas os slugs são armazenados normalizados/minúsculos. Uma query com letras maiúsculas falharia.

[Fact]
public async Task HandleAsync_WhenSlugHasUppercase_ShouldStillMatchProvider()
{
    // Arrange
    var provider = ProviderBuilder.Create()
        .WithType(EProviderType.Individual)
        .Build();
    
    var statusProp = typeof(Provider).GetProperty(nameof(Provider.Status));
    statusProp!.SetValue(provider, EProviderStatus.Active);

    // Simula query com maiúsculas, mas slug armazenado é minúsculo
    var uppercaseSlug = provider.Slug.ToUpperInvariant();
    
    _providerRepositoryMock
        .Setup(x => x.GetBySlugAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
        .ReturnsAsync((Provider?)null);

    var query = new GetPublicProviderByIdOrSlugQuery(uppercaseSlug);

    // Act
    var result = await _handler.HandleAsync(query, CancellationToken.None);

    // Assert - Documenta o comportamento atual (não encontra)
    // TODO: Decidir se deve normalizar input no handler/repository
    result.IsSuccess.Should().BeFalse();
}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 61 - 88, Add unit tests and make the handler slug handling
deterministic: add two tests in GetPublicProviderByIdOrSlugQueryHandlerTests —
one that supplies an uppercase slug (e.g., provider.Slug.ToUpperInvariant()) and
expects normalization so GetBySlugAsync matches, and one that supplies a slug
that is a valid GUID string to document/cover routing when Guid.TryParse is
true; then update HandleAsync in GetPublicProviderByIdOrSlugQueryHandler to
normalize the incoming query value (lowercase/trim) before calling
GetBySlugAsync and/or change the routing so it attempts a slug lookup fallback
when GetByIdAsync returns null (use GetByIdAsync and if null call GetBySlugAsync
with the normalized value), and update test mocks to Setup GetBySlugAsync and
GetByIdAsync (and assertions) accordingly.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (1)

61-88: Bom teste para o caminho de busca por slug, mas há duas observações.

1. Inconsistência na asserção de reflexão: Nas linhas 70-72 falta a asserção statusProp.Should().NotBeNull() que existe nos outros testes (linhas 40-42 e 144-147). Isso torna o teste menos robusto caso a propriedade seja renomeada.

2. Cobertura de teste incompleta: Não há teste para o cenário "provider não encontrado por slug". O teste HandleAsync_WhenProviderNotFound_ShouldReturnNotFound (linha 113) usa providerId.ToString() que é um GUID válido, então apenas testa o caminho de busca por ID.

♻️ Correção sugerida para a asserção

         // Bypass domain transitions to set Active status directly for test
         var statusProp = typeof(Provider).GetProperty(nameof(Provider.Status));
+        statusProp.Should().NotBeNull("Provider.Status property must exist");
         statusProp!.SetValue(provider, EProviderStatus.Active);

➕ Teste sugerido para slug não encontrado

[Fact]
public async Task HandleAsync_WhenProviderNotFoundBySlug_ShouldReturnNotFound()
{
    // Arrange
    var nonExistentSlug = "provider-inexistente-abc123";

    _providerRepositoryMock
        .Setup(x => x.GetBySlugAsync(nonExistentSlug, It.IsAny<CancellationToken>()))
        .ReturnsAsync((Provider?)null);

    var query = new GetPublicProviderByIdOrSlugQuery(nonExistentSlug);

    // Act
    var result = await _handler.HandleAsync(query, CancellationToken.None);

    // Assert
    result.IsSuccess.Should().BeFalse();
    result.Error.StatusCode.Should().Be(404);
}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 61 - 88, Add a null-check assertion for the reflected Status
property and add a new unit test for the "not found by slug" path: in
HandleAsync_WhenProviderQueriedBySlug_ShouldReturnDto ensure you assert
statusProp.Should().NotBeNull() after obtaining statusProp via
typeof(Provider).GetProperty(nameof(Provider.Status)) (symbols: Provider,
Provider.Status, statusProp,
HandleAsync_WhenProviderQueriedBySlug_ShouldReturnDto); and add a new test
HandleAsync_WhenProviderNotFoundBySlug_ShouldReturnNotFound that setups
_providerRepositoryMock.Setup(x => x.GetBySlugAsync(nonExistentSlug,
It.IsAny<CancellationToken>())).ReturnsAsync((Provider?)null), invokes new
GetPublicProviderByIdOrSlugQuery(nonExistentSlug) against
_handler.HandleAsync(...), and asserts result.IsSuccess is false and
result.Error.StatusCode equals 404 (symbols: _providerRepositoryMock,
GetBySlugAsync, GetPublicProviderByIdOrSlugQuery,
HandleAsync_WhenProviderNotFoundBySlug_ShouldReturnNotFound).

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (1)

39-43: Extrair helper para ativar Provider.Status reduziria duplicação nos testes.

O mesmo bloco de reflection aparece várias vezes. Um helper local deixaria os testes mais curtos e fáceis de manter.

Also applies to: 70-74, 103-106, 140-143, 220-223

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 39 - 43, Extract a small private helper to set Provider.Status via
reflection to remove duplication: implement a method (e.g.,
SetProviderStatus(Provider provider, EProviderStatus status)) inside
GetPublicProviderByIdOrSlugQueryHandlerTests that uses
typeof(Provider).GetProperty(nameof(Provider.Status)), asserts the property is
not null, and calls SetValue(provider, status); then replace the repeated
reflection blocks (the ones referencing Provider.Status and
EProviderStatus.Active at the multiple occurrences) with calls to this helper to
keep tests concise and consistent.

src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs (2)

48-59: Cobertura de testes ainda não valida as novas entradas nulas.

Este bloco cobre bem configuração vazia, mas faltam testes para services == null e configuration == null, que agora são comportamentos explícitos do método.

✅ Sugestão objetiva de testes complementares

+[Fact]
+public void AddUsersModule_WithNullServices_ShouldThrowArgumentNullException()
+{
+    // Arrange
+    IServiceCollection? services = null;
+    var configuration = new ConfigurationBuilder().Build();
+
+    // Act
+    var act = () => Extensions.AddUsersModule(services!, configuration);
+
+    // Assert
+    act.Should().Throw<ArgumentNullException>();
+}
+
+[Fact]
+public void AddUsersModule_WithNullConfiguration_ShouldThrowArgumentNullException()
+{
+    // Arrange
+    var services = new ServiceCollection();
+    IConfiguration? configuration = null;
+
+    // Act
+    var act = () => services.AddUsersModule(configuration!);
+
+    // Assert
+    act.Should().Throw<ArgumentNullException>();
+}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 48 - 59,
Add two unit tests to ExtensionsTests to cover the new null-argument behaviors:
one that verifies calling ServicesModule extension AddUsersModule(null,
configuration) throws ArgumentNullException for the services parameter, and
another that verifies calling services.AddUsersModule(null) throws
ArgumentNullException for the configuration parameter. Name them e.g.
AddUsersModule_WithNullServices_ShouldThrowArgumentNullException and
AddUsersModule_WithNullConfiguration_ShouldThrowArgumentNullException; use a
ServiceCollection instance and ConfigurationBuilder().Build() for non-null args,
and assert .Should().Throw<ArgumentNullException>() (optionally checking
ParamName) against the AddUsersModule extension method.

---

66-71: Pequena duplicação de setup de configuração mínima.

Vale extrair um helper para evitar repetição e facilitar manutenção dos testes.

♻️ Refactor opcional

+private static IConfiguration BuildUsersOnlyConfiguration(string connection = "Server=localhost;Database=test;")
+{
+    return new ConfigurationBuilder()
+        .AddInMemoryCollection(new Dictionary<string, string?>
+        {
+            ["ConnectionStrings:Users"] = connection
+        })
+        .Build();
+}
...
- var configuration = new ConfigurationBuilder()
-     .AddInMemoryCollection(new Dictionary<string, string?>
-     {
-         ["ConnectionStrings:Users"] = "Server=localhost;Database=test;"
-     })
-     .Build();
+ var configuration = BuildUsersOnlyConfiguration();

Also applies to: 115-118

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 66 - 71,
Extrai a criação repetida de configuração mínima para um helper reuseable: criar
um método helper (por exemplo CreateMinimalConfiguration or
BuildTestConfiguration) que retorna a IConfiguration/IConfigurationRoot usando
ConfigurationBuilder().AddInMemoryCollection(...) com a chave
"ConnectionStrings:Users" = "Server=localhost;Database=test;". Substituir as
instâncias duplicadas dentro de ExtensionsTests (aos locais que hoje fazem new
ConfigurationBuilder() com AddInMemoryCollection) para chamar esse helper; torne
o helper private static dentro da classe de testes ou num TestBase compartilhado
para evitar duplicação e facilitar manutenção.

src/Modules/Providers/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandler.cs (2)

70-70: Alinhe o naming de privacidade para reduzir ambiguidade.

Em Line 70 você passa shouldRedactContactInfo, mas o método recebe isPrivacyEnabled. Renomear o parâmetro para refletir “redact” melhora a leitura e evita interpretação errada da regra.

Also applies to: 106-109

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandler.cs`
at line 70, Renomeie o parâmetro booleano passado para os métodos de resolução
de contato para usar o mesmo termo “redact” em vez de “isPrivacyEnabled”: onde o
código chama ResolvePhoneNumbers(shouldRedactContactInfo, businessProfile) e
chamadas similares (ex.: 106-109), atualize a assinatura dos métodos (ex.:
ResolvePhoneNumbers) para aceitar um parâmetro chamado shouldRedactContactInfo
(ou renomeie a variável chamadora para isPrivacyEnabled) de modo consistente,
atualize todas as referências e testes relacionados para refletir o novo nome e
verifique que a lógica interna continue a aplicar a regra de redaction sem
alteração funcional.

---

50-53: Centralize a mensagem de NotFound para evitar duplicação.

A string "Prestador não encontrado." aparece em dois pontos. Vale extrair para constante/recurso compartilhado para manter consistência e facilitar manutenção/localização.

Based on learnings: prioritize reuse of Shared.Contracts for enums/constants to keep Web aligned with backend/shared code.

Also applies to: 57-60

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandler.cs`
around lines 50 - 53, The NotFound message "Prestador não encontrado." is
duplicated in GetPublicProviderByIdOrSlugQueryHandler; extract it into a shared
constant in the Shared.Contracts (e.g., Shared.Contracts.Messages or an existing
Errors enum/class) and replace the inline strings in the handler's
Result<PublicProviderDto?>.Failure(Error.NotFound(...)) calls (both occurrences)
to reference that shared constant (use the constant name when updating the two
Error.NotFound calls in GetPublicProviderByIdOrSlugQueryHandler).

src/Bootstrapper/MeAjudaAi.ApiService/Middlewares/SecurityHeadersMiddleware.cs (1)

45-48: Verificação de duplicação de middlewares necessária.

A alteração evita cabeçalhos duplicados verificando se já existem, o que é correto. Porém, com base na ordem do pipeline (snippets de contexto), ContentSecurityPolicyMiddleware executa antes e já define os mesmos cabeçalhos (X-Content-Type-Options, X-Frame-Options, X-XSS-Protection, Referrer-Policy, Permissions-Policy, Content-Security-Policy).

Isso significa que este middleware agora é parcialmente redundante — ele quase nunca adicionará esses cabeçalhos porque já foram definidos anteriormente.

Considere:

1. Remover os cabeçalhos duplicados de StaticHeaders e manter apenas em um middleware, ou
2. Documentar explicitamente que este middleware serve como fallback

Além disso, há uma pequena alocação de memória devido ao .Where() LINQ a cada requisição. Uma verificação dentro do loop seria marginalmente mais eficiente:

♻️ Sugestão para evitar alocação do iterador

             // Adiciona cabeçalhos de segurança estáticos eficientemente
-            foreach (var header in StaticHeaders.Where(h => !headers.ContainsKey(h.Key)))
+            foreach (var header in StaticHeaders)
             {
-                headers.Append(header.Key, header.Value);
+                if (!headers.ContainsKey(header.Key))
+                {
+                    headers.Append(header.Key, header.Value);
+                }
             }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Bootstrapper/MeAjudaAi.ApiService/Middlewares/SecurityHeadersMiddleware.cs`
around lines 45 - 48, O middleware SecurityHeadersMiddleware está redundante
porque ContentSecurityPolicyMiddleware já adiciona os mesmos cabeçalhos listados
em StaticHeaders; remova os cabeçalhos duplicados de StaticHeaders (mantendo-os
apenas em ContentSecurityPolicyMiddleware) ou documente claramente que
SecurityHeadersMiddleware é um fallback e liste apenas cabeçalhos exclusivos;
além disso, evite a alocação do iterador LINQ em cada requisição substituindo
StaticHeaders.Where(...) por um loop simples que verifica
headers.ContainsKey(header.Key) antes de chamar headers.Append — altere o
foreach na classe SecurityHeadersMiddleware para essa verificação direta.

src/Aspire/MeAjudaAi.AppHost/Program.cs (1)

71-73: Supressões de S2068 corretamente aplicadas para credenciais de desenvolvimento.

As supressões #pragma warning disable S2068 estão corretamente delimitadas apenas às linhas com valores padrão hardcoded. A lógica existente já garante que:

• Em ambientes CI (linhas 65-70 e 108-113), o processo falha se as variáveis de ambiente não estiverem definidas
• Os valores padrão ("test123", "admin123") são usados apenas em desenvolvimento/testes locais

Como sugestão opcional, considere adicionar um comentário breve explicando o motivo da supressão para facilitar revisões futuras:

 `#pragma` warning disable S2068 // Senha padrão apenas para desenvolvimento local, CI requer variável de ambiente
 testDbPassword = "test123";
 `#pragma` warning restore S2068

,

Also applies to: 114-116, 140-142

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Aspire/MeAjudaAi.AppHost/Program.cs` around lines 71 - 73, Add a one-line
explanatory comment next to each usage of "#pragma warning disable S2068" that
surrounds hardcoded development credentials so reviewers know it's intentional;
specifically, for the assignment to testDbPassword ("test123") and the analogous
assignment(s) to adminPassword ("admin123") and any other places that use the
same pragma, insert a brief comment like "Suppress S2068: intentional hardcoded
dev/test default credential, only used in local/dev scenarios; CI requires env
var" immediately before the pragma and keep the pragma scope unchanged.

src/Modules/Users/Application/Handlers/Commands/RegisterCustomerCommandHandler.cs (1)

119-119: Uso do operador null-forgiving (!) depende de contrato implícito com o domain service.

O tipo Result<T> possui o atributo [MaybeNull] em Value (conforme src/Contracts/Functional/Result.cs:24-25), indicando que Value pode ser null mesmo quando IsSuccess é true. O operador ! suprime o aviso do compilador mas não oferece proteção em runtime.

Se CreateUserAsync alguma vez retornar Value = null em caso de sucesso:

• Linha 119 lançaria NullReferenceException
• A exceção seria capturada, mas linha 130 no bloco catch também lançaria — dessa vez sem tratamento

Considerando que o padrão está sendo adotado consistentemente no PR (conforme AI summary), uma verificação defensiva opcional após o check de IsFailure aumentaria a robustez:

🛡️ Sugestão de verificação defensiva

 if (userResult.IsFailure)
 {
     logger.LogWarning("Failed to register customer {Email}: {Error}", maskedEmail, userResult.Error);
     return Result<UserDto>.Failure(userResult.Error);
 }

+if (userResult.Value is null)
+{
+    logger.LogError("CreateUserAsync returned success but Value is null for {Email}", maskedEmail);
+    return Result<UserDto>.Failure(Error.Internal("Erro inesperado no cadastro. Tente novamente."));
+}
+
+var user = userResult.Value;
+
 try
 {
-    await userRepository.AddAsync(userResult.Value!, cancellationToken);
+    await userRepository.AddAsync(user, cancellationToken);

Depois, substitua todas as ocorrências de userResult.Value! por user.

Also applies to: 130-130, 135-135, 169-171

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Users/Application/Handlers/Commands/RegisterCustomerCommandHandler.cs`
at line 119, The code uses the null-forgiving operator on userResult.Value!
(result from CreateUserAsync) which can be [MaybeNull]; add a defensive null
check after verifying userResult.IsFailure: if userResult.Value is null treat it
as a failure (log/return/throw a specific DomainException) and only then assign
var user = userResult.Value and pass user to userRepository.AddAsync and other
calls (replace all userResult.Value! uses with the local user). Also update the
catch block to avoid re-using userResult.Value! and ensure any downstream uses
(e.g., in rollback or logging) reference the validated local user or handle the
null case consistently.

src/Modules/Users/Infrastructure/Services/KeycloakUserDomainService.cs (1)

66-78: Extraia o keycloakId para melhorar reusabilidade e clareza do código.

O padrão Result<T> com verificação IsFailure é comum nesta base de código. Porém, em vez de reutilizar keycloakResult.Value! em linhas 66 e 70, extraia o valor em uma variável local para melhor legibilidade e evitar múltiplas chamadas ao Value!.

🔧 Sugestão de refatoração

+        var keycloakId = keycloakResult.Value!;
         var userResult = User.Create(username, email, firstName, lastName, keycloakResult.Value!, phoneNumber);
+        var userResult = User.Create(username, email, firstName, lastName, keycloakId, phoneNumber);
         if (userResult.IsFailure)
         {
-            var deactivationResult = await keycloakService.DeactivateUserAsync(keycloakResult.Value, CancellationToken.None);
+            var deactivationResult = await keycloakService.DeactivateUserAsync(keycloakId, CancellationToken.None);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Infrastructure/Services/KeycloakUserDomainService.cs`
around lines 66 - 78, Extraia keycloakResult.Value! para uma variável local (por
exemplo keycloakId) antes de criar o usuário para evitar repetir Value! e
melhorar clareza; use essa keycloakId ao chamar
keycloakService.DeactivateUserAsync(keycloakId, CancellationToken.None), ao
montar a mensagem do logger.LogWarning("Failed to deactivate Keycloak user
{KeycloakId}...", keycloakId, deactivationResult.Error.Message) e ao
retornar/compensar em caso de userResult.IsFailure, mantendo a lógica atual em
KeycloakUserDomainService (variáveis: keycloakResult, userResult; métodos:
DeactivateUserAsync, logger.LogWarning).

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (1)

237-270: ⚠️ Potential issue | 🟡 Minor

O cenário “privacidade desabilitada” ainda não cobre Services.

Em Line 237-270 o teste só valida Email e PhoneNumbers, mas o handler também oculta Services. Se esse campo regredir isoladamente, a suíte continua verde. Inclua um serviço conhecido na etapa de Arrange e valide o conteúdo retornado.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 237 - 270, The test
HandleAsync_WhenAuthenticatedAndPrivacyFlagDisabled_ShouldReturnFullContactInfo
currently asserts Email and PhoneNumbers but misses verifying Services; update
the Arrange to include a known service in the provider's BusinessProfile (use
ProviderBuilder/Create and the BusinessProfile/Services collection) and after
invoking _handler.HandleAsync(new GetPublicProviderByIdOrSlugQuery(...){
IsAuthenticated = true }, ...) add an assertion that result.Value.Services
contains the expected service (e.g., matching by service Id or name) to ensure
Services is returned when FeatureFlags.PublicProfilePrivacy is disabled.

src/Modules/Users/Application/Handlers/Commands/RegisterCustomerCommandHandler.cs (1)

149-153: Padronize o bloco de compensação para usar user.Id em todos os logs.

Na linha de erro de compensação ainda há dependência de userResult.Value.Id; vale manter consistente com o restante do método usando user.Id.

🔧 Ajuste sugerido

-logger.LogError("Compensation failed for user {UserId}: {Error}", userResult.Value.Id, compensationResult.Error);
+logger.LogError("Compensation failed for user {UserId}: {Error}", user.Id, compensationResult.Error);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Users/Application/Handlers/Commands/RegisterCustomerCommandHandler.cs`
around lines 149 - 153, Padronize o log de erro do bloco de compensação para
usar user.Id em vez de userResult.Value.Id; localize a chamada a
userDomainService.DeactivateUserInKeycloakAsync e o if que verifica
compensationResult.IsFailure, e atualizar a chamada
logger.LogError("Compensation failed for user {UserId}: {Error}",
userResult.Value.Id, compensationResult.Error) para passar user.Id como primeiro
argumento, mantendo a mesma mensagem e uso de compensationResult.Error.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (1)

39-40: Traduza os comentários auxiliares fora do padrão AAA.

Os cabeçalhos Arrange/Act/Assert em inglês estão ok, mas os demais comentários desta suíte também ficaram em inglês. Vale traduzir trechos como “Bypass domain transitions...” e “Fallback to slug lookup...” para manter a convenção do repositório.

Based on learnings: nos testes, apenas os headers Arrange/Act/Assert devem ficar em inglês; comentários e XML documentation devem permanecer em português.

Also applies to: 68-69, 108-109, 124-143, 163-164, 211-212

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 39 - 40, Traduza os comentários auxiliares em inglês nesta suíte de
testes para português mantendo apenas os cabeçalhos Arrange/Act/Assert em
inglês; por exemplo, substitua comentários como "Bypass domain transitions to
set Active status directly for test" e "Fallback to slug lookup..." nos testes
de GetPublicProviderByIdOrSlugQueryHandlerTests (referencie o uso de
SetProviderStatus e os blocos de teste na classe
GetPublicProviderByIdOrSlugQueryHandlerTests) e aplique a mesma tradução aos
trechos indicados (linhas correspondentes aos blocos auxiliares em 68-69,
108-109, 124-143, 163-164, 211-212) para que todos os comentários e documentação
XML fora dos cabeçalhos AAA fiquem em português.

src/Modules/Providers/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandler.cs (1)

36-48: Revise a atribuição direta de slug em SearchableProvider para garantir normalização.

O handler normaliza corretamente na leitura (linha 36), e o caminho principal de escrita (entidade Provider) sempre usa SlugHelper.GenerateWithSuffix(), que aplica ToLowerInvariant(). No entanto, SearchableProvider.Create() (linha 167) permite atribuição direta de slug sem normalização se um slug for passado explicitamente. Para evitar inconsistência entre entidades (Provider sempre normaliza; SearchableProvider pode aceitar slug não normalizado), considere adicionar validação ou normalização obrigatória no setter da propriedade Slug ou documentar que slugs devem ser pré-normalizados pelos chamadores. Isso protege contra 404s causados por diferenças de case em ambientes com collation sensível a maiúsculas.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandler.cs`
around lines 36 - 48, Atribuição direta de slug em SearchableProvider pode
aceitar valores não normalizados; atualize SearchableProvider.Create (ou o
setter da propriedade Slug) para sempre normalizar o slug usando o mesmo padrão
que Provider (por exemplo, ToLowerInvariant() e quaisquer transformações
aplicadas por SlugHelper.GenerateWithSuffix()), ou forçar validação que rejeite
slugs não-normalizados; garanta que todos os caminhos que constroem
SearchableProvider chamem essa normalização para manter consistência entre
Provider e SearchableProvider e evitar 404s por diferenças de case.

src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs (2)

7-11: Inconsistência entre documentação XML e trait de categoria.

A documentação XML na linha 8 ainda menciona "Testes de integração", mas o trait na linha 11 foi alterado para "Unit". Considere atualizar a documentação para manter consistência.

📝 Correção sugerida

 /// <summary>
-/// Testes de integração dos métodos de extensão do módulo Users
-/// Foca em cenários de integração e configuração completa
+/// Testes unitários dos métodos de extensão do módulo Users
+/// Foca em cenários de configuração e registro de serviços
 /// </summary>
 [Trait("Category", "Unit")]

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 7 - 11, The
XML documentation summary on the ExtensionsTests.cs file currently says "Testes
de integração dos métodos de extensão do módulo Users" but the test is marked
with [Trait("Category", "Unit")]; update the XML <summary> to reflect unit tests
(e.g., "Testes unitários dos métodos de extensão do módulo Users") so the
docstring and the [Trait("Category", "Unit")] attribute are consistent; locate
the XML comment above the test class or file header and change the phrase
"integração" to "unitários".

---

90-105: Considere também limpar DOTNET_ENVIRONMENT para evitar falhas intermitentes.

O método IsSecurityBypassEnvironment() (conforme context snippet 3) verifica tanto DOTNET_ENVIRONMENT quanto ASPNETCORE_ENVIRONMENT. Se o ambiente de CI/CD definir DOTNET_ENVIRONMENT como "Development" ou "Testing", o teste pode falhar inesperadamente, pois a condição de bypass será satisfeita mesmo com ASPNETCORE_ENVIRONMENT configurado como "Production".

Além disso, a manipulação de variáveis de ambiente globais pode causar condições de corrida se os testes executarem em paralelo.

🛡️ Correção sugerida para maior robustez

         var originalEnv = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+        var originalDotnetEnv = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT");
         try
         {
             // Força ambiente não teste/dev para testar o fallback de exception
             Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Production");
+            Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", "Production");
 
             // Act & Assert
             var act = () => services.AddUsersModule(configuration);
             
             act.Should().Throw<InvalidOperationException>()
                .WithMessage("Connection for Users module not configured");
         }
         finally
         {
             Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", originalEnv);
+            Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", originalDotnetEnv);
         }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 90 - 105,
The test relies on IsSecurityBypassEnvironment() which reads both
DOTNET_ENVIRONMENT and ASPNETCORE_ENVIRONMENT, so update the test to also save
and restore the original DOTNET_ENVIRONMENT, and clear or set it to a non-bypass
value before asserting the exception: capture
Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") into a local variable,
call Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", null) or
"Production" before Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT",
"Production"), run the act/assert against
services.AddUsersModule(configuration), and restore both environment variables
in the finally block; additionally consider marking the test to prevent parallel
execution if environment mutation could race with other tests.

src/Modules/SearchProviders/Domain/Entities/SearchableProvider.cs (1)

160-168: Evite exceção como fluxo normal no Reconstitute.

Aqui o catch pode virar caminho frequente para dados legados; vale simplificar com checagem explícita e fallback sem exceção.

♻️ Proposta de ajuste

-        string normalizedSlug;
-        try
-        {
-            normalizedSlug = NormalizeAndValidateSlug(slug);
-        }
-        catch (ArgumentException)
-        {
-            normalizedSlug = SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]);
-        }
+        var normalizedSlug = SlugHelper.Generate(slug ?? string.Empty);
+        if (string.IsNullOrWhiteSpace(normalizedSlug))
+        {
+            normalizedSlug = SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]);
+        }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/SearchProviders/Domain/Entities/SearchableProvider.cs` around
lines 160 - 168, No use exceções como fluxo normal em Reconstitute: remova o
try/catch que chama NormalizeAndValidateSlug(slug) e, em vez disso,
implementar/ver usar uma versão não-throwing (por exemplo
TryNormalizeSlug(string slug, out string normalized) ou um IsValidSlug check)
para validar e normalizar antes do fallback; se TryNormalizeSlug retornar true
use o normalized, caso contrário gere o slug de fallback com
SlugHelper.GenerateWithSuffix(name, providerId.ToString("N")[..8]).
Certifique-se de atualizar/usar o método NormalizeAndValidateSlug ou adicionar
TryNormalizeSlug para evitar lançar ArgumentException no caminho normal.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (2)

68-69: Padronize os comentários não-AAA para português.

Os blocos de comentário nesses trechos estão em inglês; para manter consistência do repositório, vale migrar para português e manter apenas os headers AAA em inglês.

Based on learnings: "Adopt a language policy across the codebase: comments/XML summaries em português" e "In unit test code, keep AAA headers (Arrange, Act, Assert) in English."

Also applies to: 98-99, 133-134

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 68 - 69, Substitua os comentários explicativos não-AAA pelo
equivalente em português no bloco que precede a chamada
SetProviderStatus(provider, EProviderStatus.Active) — mantenha apenas os headers
AAA (Arrange/Act/Assert) em inglês — e aplique a mesma padronização nos outros
blocos de comentário mencionados (os dois blocos adicionais indicados pelo
revisor).

---

122-155: O teste de fallback não comprova explicitamente o caminho ID → slug.

O cenário em Line 122-155 valida o resultado final, mas não garante que o handler tentou GetByIdAsync e depois fez fallback para GetBySlugAsync. Vale fortalecer com Verify (e, se quiser, MockSequence) para evitar falso-positivo em refactors futuros.

💡 Ajuste sugerido

-        _providerRepositoryMock
-            .Setup(x => x.GetByIdAsync(It.IsAny<ProviderId>(), It.IsAny<CancellationToken>()))
+        _providerRepositoryMock
+            .Setup(x => x.GetByIdAsync(It.Is<ProviderId>(id => id.Value == slugGuid), It.IsAny<CancellationToken>()))
             .ReturnsAsync((Provider?)null);

         // Fallback para a busca por slug retorna o provedor
         _providerRepositoryMock
             .Setup(x => x.GetBySlugAsync(slugValue, It.IsAny<CancellationToken>()))
             .ReturnsAsync(provider);
@@
         result.IsSuccess.Should().BeTrue();
         result.Value.Should().NotBeNull();
         result.Value!.Id.Should().Be(provider.Id);
+
+        _providerRepositoryMock.Verify(
+            x => x.GetByIdAsync(It.Is<ProviderId>(id => id.Value == slugGuid), It.IsAny<CancellationToken>()),
+            Times.Once);
+        _providerRepositoryMock.Verify(
+            x => x.GetBySlugAsync(slugValue, It.IsAny<CancellationToken>()),
+            Times.Once);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 122 - 155, In the test
HandleAsync_WhenSlugIsValidGuidString_ShouldFallbackToSlugLookup, explicitly
verify that the handler attempted an ID lookup then fell back to a slug lookup
by calling Verify on _providerRepositoryMock: assert GetByIdAsync was invoked
once with a ProviderId corresponding to slugGuid (or matching its Value) and
that GetBySlugAsync was invoked once with slugValue; optionally use MockSequence
to enforce call order. This ensures the test checks the ID→slug path rather than
only the final result.

src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs (1)

8-10: Ajustar o XML summary para refletir foco unitário.

Na Line 9, “cenários de integração” conflita com [Trait("Category", "Unit")]. Vale alinhar a descrição para evitar ambiguidade na documentação do teste.

💡 Diff sugerido

 /// <summary>
 /// Testes unitários dos métodos de extensão do módulo Users
-/// Foca em cenários de integração e configuração completa
+/// Foca em cenários unitários de configuração e contrato do módulo
 /// </summary>

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 8 - 10,
Ajuste o XML <summary> do arquivo ExtensionsTests.cs para refletir que estes são
testes unitários: remova ou substitua a frase “cenários de integração” por algo
como “cenários unitários” ou “cenários focados em unidade” para alinhar com
[Trait("Category", "Unit")] e evitar ambiguidade; busque o comentário XML acima
da classe/método ExtensionsTests e atualize a descrição para indicar claramente
foco unitário.

src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs (1)

80-148: LGTM!

Excelente cobertura de testes para a validação de slug:

• Testes de rejeição para slugs vazios e com espaços em branco
• Testes de normalização para lowercase
• Mensagens de erro em português validadas corretamente nas assertions

Considere adicionar um teste para slugs compostos apenas por caracteres especiais (ex: "!!!"), que também devem ser rejeitados após normalização resultar em string vazia.

💡 Teste sugerido

[Fact]
public void Create_WithSpecialCharactersOnlySlug_ShouldThrowArgumentException()
{
    // Arrange
    var providerId = Guid.NewGuid();
    var location = new GeoPoint(-23.5505, -46.6333);

    // Act
    var act = () => SearchableProvider.Create(providerId, "Valid Name", "!!!", location);

    // Assert
    act.Should().Throw<ArgumentException>()
        .WithMessage("*O identificador do provedor não pode estar vazio nem em formato inválido*");
}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs`
around lines 80 - 148, Add a unit test that ensures slugs made only of special
characters are rejected: create a new test similar to Create_WithEmptySlug but
call SearchableProvider.Create(providerId, "Valid Name", "!!!", location) and
assert it throws ArgumentException with the same message pattern ("*O
identificador do provedor não pode estar vazio nem em formato inválido*"); this
verifies SearchableProvider.Create (and by extension normalization logic used by
UpdateBasicInfo) fails when normalization yields an empty slug.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (3)

214-215: Padronize este comentário inline para português.

Os cabeçalhos AAA podem ficar em inglês, mas esse comentário ficou fora da convenção do repositório. Algo como // Ignora transições de domínio para definir o status Active diretamente no teste já resolve. Based on learnings: In all C# files, keep logging messages in English, but ensure comments and XML documentation (///

, /// , etc.) are written in Portuguese across the codebase. In unit test code (e.g., under any .../Tests/…/*.cs), keep AAA headers in tests (Arrange, Act, Assert) in English and do not translate them.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 214 - 215, Altere o comentário inline que precede a chamada
SetProviderStatus(provider, EProviderStatus.Active) para português, por exemplo:
"// Ignora transições de domínio para definir o status Active diretamente no
teste"; mantenha os cabeçalhos AAA (Arrange, Act, Assert) em inglês nos testes e
preserve mensagens de log em inglês, enquanto comentários e documentação XML
(///) no código C# devem estar em português.

---

71-77: Os testes ainda não exercitam o Trim() da normalização do slug.

O setup espera provider.Slug.Trim().ToLowerInvariant(), mas as queries passam o slug sem espaços extras (provider.Slug / ToUpperInvariant()). Se o handler perder o Trim(), essa suíte continua verde. Vale adicionar um caso com espaços nas pontas, por exemplo " {provider.Slug.ToUpperInvariant()} ".

Also applies to: 101-109

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 71 - 77, The test currently sets up _providerRepositoryMock to
expect normalizedSlug (provider.Slug.Trim().ToLowerInvariant()) but calls new
GetPublicProviderByIdOrSlugQuery(provider.Slug), so Trim() isn't exercised; add
a test variant that passes a slug with leading/trailing spaces and different
casing (e.g. $"  {provider.Slug.ToUpperInvariant()}  ") to
GetPublicProviderByIdOrSlugQuery and update the mock setup to expect the
handler's normalized value (call Trim() and ToLowerInvariant() on that dirty
input) so the test will fail if the handler omits Trim() or case normalization
(reference normalizedSlug, _providerRepositoryMock.Setup and
GetPublicProviderByIdOrSlugQuery).

---

279-284: Adicione WithStatus(...) ou AsActive() ao ProviderBuilder para abstrair a reflexão.

O ProviderBuilder não expõe métodos para configurar Provider.Status. O helper SetProviderStatus que usa reflexão é necessário atualmente, mas essa abordagem acopla os testes ao detalhe de implementação. Adicione um método de fluência (como WithStatus() ou AsActive()) ao builder, similar aos existentes (WithTier(), AsIndividual(), etc.), para abstrair essa configuração e remover a necessidade do helper em 6 pontos de teste diferentes.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 279 - 284, Add a fluent setter on ProviderBuilder (e.g.,
WithStatus(EProviderStatus status) and/or AsActive()) to configure
Provider.Status instead of using the reflection helper SetProviderStatus;
implement the builder method to store the chosen status and apply it when
building the Provider (mirror existing patterns used by WithTier/AsIndividual),
then update the six tests to call the new builder method and remove usages of
SetProviderStatus and the reflection helper.

src/Modules/Providers/Tests/Builders/ProviderBuilder.cs (1)

84-93: Considere extrair um helper para evitar duplicação de reflexão (Tier e Status).

O bloco novo repete o mesmo fluxo de GetProperty + throw + SetValue já usado para Tier; centralizar isso reduz risco de divergência futura.

♻️ Refatoração sugerida

                 // Define tier se especificado
                 if (_tier.HasValue)
                 {
-                    var prop = typeof(Provider).GetProperty(nameof(Provider.Tier));
-                    if (prop == null)
-                    {
-                        throw new InvalidOperationException($"Property '{nameof(Provider.Tier)}' was not found on class {nameof(Provider)}.");
-                    }
-                    prop.SetValue(provider, _tier.Value);
+                    SetPropertyOrThrow(provider, nameof(Provider.Tier), _tier.Value);
                 }

                 // Define status se especificado
                 if (_status.HasValue)
                 {
-                    var prop = typeof(Provider).GetProperty(nameof(Provider.Status));
-                    if (prop == null)
-                    {
-                        throw new InvalidOperationException($"Property '{nameof(Provider.Status)}' was not found on class {nameof(Provider)}.");
-                    }
-                    prop.SetValue(provider, _status.Value);
+                    SetPropertyOrThrow(provider, nameof(Provider.Status), _status.Value);
                 }

+    private static void SetPropertyOrThrow<T>(Provider provider, string propertyName, T value)
+    {
+        var prop = typeof(Provider).GetProperty(propertyName);
+        if (prop == null)
+        {
+            throw new InvalidOperationException($"Property '{propertyName}' was not found on class {nameof(Provider)}.");
+        }
+
+        prop.SetValue(provider, value);
+    }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Providers/Tests/Builders/ProviderBuilder.cs` around lines 84 -
93, The reflection logic for setting Provider.Status duplicates the flow used
for Provider.Tier; extract a private helper on ProviderBuilder (e.g.,
SetProviderProperty(provider, string propertyName, object value) or
SetPropertyValue) that does typeof(Provider).GetProperty(propertyName), throws
the same InvalidOperationException if null, and calls SetValue, then replace the
direct reflection blocks in the Tier and Status branches to call that helper
with nameof(Provider.Tier)/nameof(Provider.Status) and the corresponding value;
ensure the helper signature and exception text match the existing style so
behavior remains identical.

src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs (2)

23-28: Defina um padrão explícito para a feature flag no setup comum.

Hoje vários testes dependem de retorno implícito do mock para IsEnabledAsync. Deixar PublicProfilePrivacy = false explícito no construtor melhora determinismo e legibilidade da suíte.

♻️ Ajuste sugerido

 public GetPublicProviderByIdOrSlugQueryHandlerTests()
 {
     _providerRepositoryMock = new Mock<IProviderRepository>();
     _featureManagerMock = new Mock<IFeatureManager>();
+    _featureManagerMock
+        .Setup(x => x.IsEnabledAsync(FeatureFlags.PublicProfilePrivacy))
+        .ReturnsAsync(false);
     _handler = new GetPublicProviderByIdOrSlugQueryHandler(_providerRepositoryMock.Object, _featureManagerMock.Object);
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 23 - 28, No construtor de
GetPublicProviderByIdOrSlugQueryHandlerTests deixe explícito o comportamento da
feature flag: configure o mock _featureManagerMock para retornar false quando
IsEnabledAsync for chamado para a flag "PublicProfilePrivacy" (por exemplo
usando Setup/SetupSequence para
_featureManagerMock.IsEnabledAsync("PublicProfilePrivacy", ...) retornando
Task.FromResult(false)); isso garante que todos os testes partam de um padrão
determinístico e legível ao invés de depender do retorno implícito do mock.

---

187-227: Cobertura negativa por slug ainda está incompleta.

Os cenários negativos (inativo e não encontrado) só exercitam consulta por ID. Vale adicionar equivalentes por slug para evitar regressão específica desse caminho.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/Providers/Tests/Unit/Application/Handlers/Queries/GetPublicProviderByIdOrSlugQueryHandlerTests.cs`
around lines 187 - 227, Add equivalent negative tests that exercise the slug
path in GetPublicProviderByIdOrSlugQueryHandlerTests: create two new facts named
HandleAsync_WhenProviderIsNotActive_BySlug_ShouldReturnNotFound and
HandleAsync_WhenProviderNotFound_BySlug_ShouldReturnNotFound that mirror the
existing ID-based tests but construct GetPublicProviderByIdOrSlugQuery with the
provider slug string, set up the repository mock to respond to the slug lookup
(e.g., Setup(x => x.GetBySlugAsync(provider.Slug,
It.IsAny<CancellationToken>())) to return the inactive provider or null
respectively), invoke _handler.HandleAsync(query, CancellationToken.None) and
assert result.IsSuccess is false and result.Error.StatusCode is 404. Ensure you
use ProviderBuilder to provide a slug for the first test and a random slug for
the not-found test so the slug-specific code path is covered.

src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs (1)

103-104: Evite acoplar este teste ao texto literal de uma exceção da infraestrutura.

Em src/Modules/Users/API/Extensions.cs:17-29, AddUsersModule só faz os guards de null e delega para AddInfrastructure(configuration). Validar aqui a mensagem exata transforma este teste do módulo em um teste do detalhe interno da infraestrutura; qualquer ajuste de texto lá quebra a suíte sem alterar o contrato público deste método.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 103 - 104,
O teste está acoplado ao texto literal da exceção da infraestrutura; abra
ExtensionsTests.cs, localize a asserção que usa
act.Should().Throw<InvalidOperationException>().WithMessage("Connection for
Users module not configured") e remova a verificação de mensagem mantendo apenas
a asserção de tipo (act.Should().Throw<InvalidOperationException>()), pois
AddUsersModule delega para AddInfrastructure e o contrato público do módulo deve
ser testado pelo tipo da exceção, não pelo texto exato.

src/Modules/Providers/Tests/Builders/ProviderBuilder.cs (1)

227-236: Boa consolidação da lógica de reflection.

O helper SetPropertyValue centraliza o código de reflection, facilitando manutenção e evitando duplicação. A validação da existência da propriedade com exceção clara é apropriada para infraestrutura de testes.

Opcionalmente, para maior robustez, você poderia validar se a propriedade possui um setter antes de chamar SetValue:

♻️ Sugestão opcional de validação adicional

 private static void SetPropertyValue(Provider provider, string propertyName, object value)
 {
-    var prop = typeof(Provider).GetProperty(propertyName);
+    var prop = typeof(Provider).GetProperty(propertyName)
+        ?? throw new InvalidOperationException($"Property '{propertyName}' was not found on class {nameof(Provider)}.");
+    
-    if (prop == null)
-    {
-        throw new InvalidOperationException($"Property '{propertyName}' was not found on class {nameof(Provider)}.");
-    }
+    if (!prop.CanWrite)
+    {
+        throw new InvalidOperationException($"Property '{propertyName}' on class {nameof(Provider)} does not have a setter.");
+    }
+    
     prop.SetValue(provider, value);
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Providers/Tests/Builders/ProviderBuilder.cs` around lines 227 -
236, The SetPropertyValue helper currently assumes the discovered PropertyInfo
is writable; update SetPropertyValue to verify the property has a setter (e.g.,
check prop.CanWrite or prop.GetSetMethod(true) != null) before calling
prop.SetValue and throw a clear InvalidOperationException if the property is
read-only on Provider, so callers get a descriptive error instead of a runtime
exception from SetValue.

src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs (1)

20-23: Padronize a chave de connection string para evitar cobertura ambígua

No mesmo arquivo, alguns cenários usam ConnectionStrings:Users (Line 22) e outros usam ConnectionStrings:DefaultConnection (ex.: Line 61/134/183). Vale unificar para reduzir falso positivo de cobertura em caminhos diferentes de configuração.

💡 Sugestão de ajuste

     return new ConfigurationBuilder()
         .AddInMemoryCollection(new Dictionary<string, string?>
         {
             ["ConnectionStrings:Users"] = "Server=localhost;Database=test;"
+            ,["ConnectionStrings:DefaultConnection"] = "Server=localhost;Database=test;"
         })
         .Build();

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/Modules/Users/Tests/Unit/API/ExtensionsTests.cs` around lines 20 - 23,
Padronize a chave da connection string nos testes para evitar caminhos de
configuração diferentes: substitua todas as ocorrências divergentes
("ConnectionStrings:Users" e "ConnectionStrings:DefaultConnection") por uma
única chave consistente — por exemplo "ConnectionStrings:DefaultConnection" — em
todo o arquivo ExtensionsTests.cs e nos outros cenários de teste que referenciam
essas chaves; busque pelas strings "ConnectionStrings:Users" e
"ConnectionStrings:DefaultConnection" e atualize os valores no
AddInMemoryCollection e nos asserts/consumos correspondentes para usar apenas a
chave escolhida.

src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs (1)

17-49: Adicione assert explícito de Slug nos happy paths principais.

Os testes já passam slug, mas não verificam explicitamente o valor final em Create_WithValidData e UpdateBasicInfo_WithValidData.

💡 Diff sugerido

@@
         provider.ProviderId.Should().Be(providerId);
         provider.Name.Should().Be(name);
+        provider.Slug.Should().Be("test-provider");
         provider.Location.Should().Be(location);
@@
         provider.UpdateBasicInfo(newName, "updated-provider", newDescription, newCity, newState);
@@
         provider.Name.Should().Be(newName);
+        provider.Slug.Should().Be("updated-provider");
         provider.Description.Should().Be(newDescription);

Also applies to: 166-184

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs`
around lines 17 - 49, The tests call SearchableProvider.Create and
UpdateBasicInfo but don't assert the Slug value; add explicit assertions for the
Slug property in Create_WithValidData_ShouldCreateSearchableProvider and
UpdateBasicInfo_WithValidData to validate the final slug value (e.g., assert
provider.Slug equals the expected "test-provider" after Create, and assert it
equals the updated slug after calling UpdateBasicInfo), referencing the
SearchableProvider.Create and UpdateBasicInfo flows to locate where to add the
checks.

src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs (1)

96-108: Inconsistência na asserção da mensagem de erro.

O teste Create_WithEmptySlug_ShouldThrowArgumentException (linhas 92-93) valida a mensagem de erro específica, mas este teste para slug com espaços em branco não faz a mesma validação. Para garantir consistência e verificar que o caminho de validação correto está sendo exercitado, considere adicionar a mesma asserção de mensagem.

♻️ Sugestão para adicionar asserção da mensagem

         // Assert
-        act.Should().Throw<ArgumentException>();
+        act.Should().Throw<ArgumentException>()
+            .WithMessage("*O identificador do provedor não pode estar vazio nem em formato inválido*");

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@src/Modules/SearchProviders/Tests/Unit/Domain/Entities/SearchableProviderTests.cs`
around lines 96 - 108, The test
Create_WithWhitespaceSlug_ShouldThrowArgumentException currently only asserts an
ArgumentException is thrown; update it to also assert the exception message
matches the same expected message used in
Create_WithEmptySlug_ShouldThrowArgumentException by chaining the message
assertion on the thrown exception from SearchableProvider.Create (i.e., assert
the exception's Message equals the same expected error string used in the other
test to ensure consistency of validation).